O'lchamlanuvchi, qo'llab-quvvatlanadigan va testlanadigan ilovalar yaratish uchun FastAPI'dagi ilg'or bog'liqliklarni kiritish usullarini o'rganing. Mustahkam DI konteynerini qanday tuzishni bilib oling.
FastAPI Bog'liqliklarni Kiritish: Ilg'or DI Konteyner Arxitekturasi
FastAPI, o'zining intuitiv dizayni va kuchli xususiyatlari bilan Python'da zamonaviy veb API'lar yaratish uchun sevimli vositaga aylandi. Uning asosiy kuchli tomonlaridan biri bu bog'liqliklarni kiritish (DI) bilan uzluksiz integratsiyalashuvidir, bu esa dasturchilarga bo'sh bog'langan, testlanadigan va qo'llab-quvvatlanadigan ilovalar yaratish imkonini beradi. FastAPI'ning o'rnatilgan DI tizimi oddiy holatlar uchun a'lo darajada bo'lsa-da, murakkabroq loyihalar ko'pincha yanada tizimli va ilg'or DI konteyner arxitekturasidan foyda ko'radi. Ushbu maqola shunday arxitekturani yaratishning turli strategiyalarini o'rganib chiqadi, mustahkam va o'lchamlanuvchi ilovalarni loyihalash uchun amaliy misollar va tushunchalar taqdim etadi.
Bog'liqliklarni Kiritish (DI) va Boshqaruvni Inversiyalash (IoC) ni Tushunish
Ilg'or DI konteyner arxitekturalariga sho'ng'ishdan oldin, asosiy tushunchalarga aniqlik kiritib olaylik:
- Bog'liqliklarni Kiritish (DI): Bu dizayn namunasi bo'lib, unda bog'liqliklar komponentga ichki ravishda yaratilish o'rniga tashqi manbalardan taqdim etiladi. Bu bo'sh bog'lanishni rag'batlantiradi, komponentlarni testlash va qayta ishlatishni osonlashtiradi.
- Boshqaruvni Inversiyalash (IoC): Bu kengroq tamoyil bo'lib, unda obyektlarni yaratish va boshqarish nazorati teskari aylantiriladi – freymvork yoki konteynerga topshiriladi. DI IoC'ning maxsus bir turidir.
FastAPI o'zining bog'liqliklar tizimi orqali DI'ni tabiiy ravishda qo'llab-quvvatlaydi. Siz bog'liqliklarni chaqiriladigan obyektlar (funksiyalar, sinflar va h.k.) sifatida belgilaysiz va FastAPI ularni avtomatik ravishda aniqlaydi va sizning endpoint funksiyalaringizga yoki boshqa bog'liqliklarga kiritadi.
Misol (Asosiy FastAPI DI):
from fastapi import FastAPI, Depends
app = FastAPI()
# Bog'liqlik
def get_db():
db = {"items": []} # Ma'lumotlar bazasi ulanishini simulyatsiya qilish
try:
yield db
finally:
# Ma'lumotlar bazasi ulanishini yopish (agar kerak bo'lsa)
pass
# Bog'liqlik kiritilgan endpoint
@app.get("/items/")
async def read_items(db: dict = Depends(get_db)):
return db["items"]
Ushbu misolda get_db ma'lumotlar bazasi ulanishini ta'minlaydigan bog'liqlikdir. FastAPI avtomatik ravishda get_db'ni chaqiradi va natijani (db lug'atini) read_items endpoint funksiyasiga kiritadi.
Nima Uchun Ilg'or DI Konteyner Kerak?
FastAPI'ning o'rnatilgan DI tizimi oddiy loyihalar uchun yaxshi ishlaydi, ammo ilovalar murakkablashgan sari, yanada rivojlangan DI konteyner bir nechta afzalliklarni taqdim etadi:
- Markazlashtirilgan Bog'liqliklarni Boshqarish: Maxsus konteyner barcha bog'liqliklar uchun yagona haqiqat manbasini ta'minlaydi, bu esa ilovaning bog'liqliklarini boshqarish va tushunishni osonlashtiradi.
- Konfiguratsiya va Hayot Davrini Boshqarish: Konteyner bog'liqliklarning konfiguratsiyasi va hayot davrini boshqarishi mumkin, masalan, singletonlar yaratish, ulanishlarni boshqarish va resurslarni yo'q qilish.
- Testlanuvchanlik: Ilg'or konteyner bog'liqliklarni soxta (mock) obyektlar yoki test dublyorlari bilan osongina almashtirish imkonini berib, testlashni soddalashtiradi.
- Bog'liqlikni uzish: Komponentlar o'rtasida katta darajada bog'liqlikni uzishga yordam beradi, bog'liqliklarni kamaytiradi va kodning qo'llab-quvvatlanuvchanligini yaxshilaydi.
- Kengaytiriluvchanlik: Kengaytiriladigan konteyner kerak bo'lganda maxsus xususiyatlar va integratsiyalarni qo'shish imkonini beradi.
Ilg'or DI Konteyner Yaratish Strategiyalari
FastAPI'da ilg'or DI konteyner yaratishning bir nechta yondashuvlari mavjud. Quyida ba'zi umumiy strategiyalar keltirilgan:
1. Maxsus DI Kutubxonasidan Foydalanish (masalan, `injector`, `dependency_injector`)
Python uchun `injector` va `dependency_injector` kabi bir nechta kuchli DI kutubxonalari mavjud. Bu kutubxonalar bog'liqliklarni boshqarish uchun keng qamrovli xususiyatlar to'plamini taqdim etadi, jumladan:
- Bog'lash: Bog'liqliklar qanday aniqlanishi va kiritilishini belgilash.
- Skoplar: Bog'liqliklarning hayot davrini nazorat qilish (masalan, singleton, vaqtinchalik).
- Konfiguratsiya: Bog'liqliklar uchun konfiguratsiya sozlamalarini boshqarish.
- AOP (Aspektga Yo'naltirilgan Dasturlash): Kesishuvchi vazifalar uchun metod chaqiruvlarini to'xtatib turish.
`dependency_injector` bilan misol
dependency_injector DI konteynerlarini yaratish uchun mashhur tanlovdir. Keling, uning ishlatilishini misol bilan ko'rib chiqamiz:
from dependency_injector import containers, providers
from fastapi import FastAPI, Depends
# Bog'liqliklarni aniqlash
class Database:
def __init__(self, connection_string: str):
self.connection_string = connection_string
# Ma'lumotlar bazasi ulanishini initsializatsiya qilish
print(f"Ma'lumotlar bazasiga ulanish: {self.connection_string}")
def get_items(self):
# Ma'lumotlar bazasidan elementlarni olishni simulyatsiya qilish
return [{"id": 1, "name": "Item 1"}, {"id": 2, "name": "Item 2"}]
class UserRepository:
def __init__(self, database: Database):
self.database = database
def get_all_users(self):
# Barcha foydalanuvchilarni olish uchun ma'lumotlar bazasiga so'rovni simulyatsiya qilish
return [{"id": "user1", "name": "Alice"},{"id": "user2", "name": "Bob"}]
class Settings:
def __init__(self, database_url):
self.database_url = database_url
# Konteynerni aniqlash
class Container(containers.DeclarativeContainer):
config = providers.Configuration()
settings = providers.Singleton(Settings, database_url = config.database_url)
database = providers.Singleton(Database, connection_string=config.database_url)
user_repository = providers.Factory(UserRepository, database=database)
# FastAPI ilovasini yaratish
app = FastAPI()
# Konteynerni sozlash (muhit o'zgaruvchisidan)
container = Container()
container.config.database_url.from_env("DATABASE_URL", default="sqlite:///:memory:")
container.wire([__name__]) # FastAPI endpoint'lariga bog'liqliklarni kiritishni yoqadi
# FastAPI uchun bog'liqlik
def get_user_repository(user_repository: UserRepository = Depends(container.user_repository.provided)) -> UserRepository:
return user_repository
# Kiritilgan bog'liqlikdan foydalanadigan endpoint
@app.get("/users/")
async def read_users(user_repository: UserRepository = Depends(get_user_repository)):
return user_repository.get_all_users()
@app.on_event("startup")
async def startup_event():
# Konteynerni initsializatsiya qilish
container.init_resources()
Tushuntirish:
- Biz o'z bog'liqliklarimizni (
Database,UserRepository,Settings) oddiy Python sinflari sifatida belgilaymiz. - Biz
containers.DeclarativeContainer'dan meros oluvchiContainersinfini yaratamiz. Bu sinf bog'liqliklarni va ularning provayderlarini (masalan, singletonlar uchunproviders.Singleton, har safar yangi nusxa yaratish uchunproviders.Factory) belgilaydi. container.wire([__name__])qatori FastAPI endpoint'lariga bog'liqliklarni kiritish imkonini beradi.get_user_repositoryfunksiyasi FastAPI bog'liqligi bo'lib, u UserRepository nusxasini konteynerdan olish uchuncontainer.user_repository.provided'dan foydalanadi.read_usersendpoint funksiyasiUserRepositorybog'liqligini kiritadi.configsizga bog'liqlik konfiguratsiyalarini tashqariga chiqarish imkonini beradi. Keyin u muhit o'zgaruvchilari, konfiguratsiya fayllari va hokazolardan olinishi mumkin.startup_eventkonteynerda boshqariladigan resurslarni initsializatsiya qilish uchun ishlatiladi.
2. Maxsus DI Konteynerni Yaratish
DI jarayoni ustidan ko'proq nazorat qilish uchun siz maxsus DI konteynerni yaratishingiz mumkin. Bu yondashuv ko'proq harakat talab qiladi, lekin konteynerni o'zingizning maxsus ehtiyojlaringizga moslashtirish imkonini beradi.
Oddiy Maxsus DI Konteyner Misoli:
from typing import Callable, Dict, Type, Any
from fastapi import FastAPI, Depends
class Container:
def __init__(self):
self.dependencies: Dict[Type[Any], Callable[..., Any]] = {}
self.instances: Dict[Type[Any], Any] = {}
def register(self, dependency_type: Type[Any], provider: Callable[..., Any]):
self.dependencies[dependency_type] = provider
def resolve(self, dependency_type: Type[Any]) -> Any:
if dependency_type in self.instances:
return self.instances[dependency_type]
if dependency_type not in self.dependencies:
raise Exception(f"Bog'liqlik {dependency_type} ro'yxatdan o'tmagan.")
provider = self.dependencies[dependency_type]
instance = provider()
return instance
def singleton(self, dependency_type: Type[Any], provider: Callable[..., Any]):
self.register(dependency_type, provider)
self.instances[dependency_type] = provider()
# Misol Bog'liqliklar
class PaymentGateway:
def process_payment(self, amount: float) -> bool:
print(f"${amount} miqdoridagi to'lovni qayta ishlash")
return True # Muvaffaqiyatli to'lovni simulyatsiya qilish
class NotificationService:
def send_notification(self, message: str):
print(f"Bildirishnoma yuborish: {message}")
# Foydalanish Misoli
container = Container()
container.singleton(PaymentGateway, PaymentGateway)
container.singleton(NotificationService, NotificationService)
app = FastAPI()
# FastAPI Bog'liqligi
def get_payment_gateway(payment_gateway: PaymentGateway = Depends(lambda: container.resolve(PaymentGateway))):
return payment_gateway
def get_notification_service(notification_service: NotificationService = Depends(lambda: container.resolve(NotificationService))):
return notification_service
@app.post("/purchase/")
async def purchase_item(payment_gateway: PaymentGateway = Depends(get_payment_gateway), notification_service: NotificationService = Depends(get_notification_service)):
if payment_gateway.process_payment(100.0):
notification_service.send_notification("Xarid muvaffaqiyatli amalga oshirildi!")
return {"message": "Xarid muvaffaqiyatli amalga oshirildi"}
else:
return {"message": "Xarid amalga oshmadi"}
Tushuntirish:
Containersinfi bog'liqliklar va ularning provayderlari lug'atini boshqaradi.registermetodi bog'liqlikni uning provayderi bilan ro'yxatdan o'tkazadi.resolvemetodi bog'liqlikni uning provayderini chaqirish orqali hal qiladi.singletonmetodi bog'liqlikni ro'yxatdan o'tkazadi va uning yagona nusxasini yaratadi.- FastAPI bog'liqliklari konteynerdan bog'liqliklarni hal qilish uchun lambda funksiyasidan foydalanib yaratiladi.
3. FastAPI'ning `Depends`'ini Fabrika Funksiyasi Bilan Ishlatish
To'liq DI konteyner o'rniga, siz bog'liqliklarni boshqarishning ma'lum darajasiga erishish uchun FastAPI'ning `Depends`'ini fabrika funksiyalari bilan birgalikda ishlatishingiz mumkin. Bu yondashuv maxsus konteynerni yaratishdan ko'ra soddaroq, ammo baribir endpoint funksiyalari ichida bog'liqliklarni to'g'ridan-to'g'ri yaratishdan ko'ra ba'zi afzalliklarni taqdim etadi.
from fastapi import FastAPI, Depends
from typing import Callable
# Bog'liqliklarni Aniqlash
class EmailService:
def __init__(self, smtp_server: str):
self.smtp_server = smtp_server
def send_email(self, recipient: str, subject: str, body: str):
print(f"{recipient} ga {self.smtp_server} orqali xat yuborish: {subject} - {body}")
# EmailService uchun fabrika funksiyasi
def create_email_service(smtp_server: str) -> EmailService:
return EmailService(smtp_server=smtp_server)
# FastAPI
app = FastAPI()
# FastAPI Bog'liqligi, fabrika funksiyasi va Depends'dan foydalanish
def get_email_service(email_service: EmailService = Depends(lambda: create_email_service(smtp_server="smtp.example.com"))):
return email_service
@app.post("/send-email/")
async def send_email(recipient: str, subject: str, body: str, email_service: EmailService = Depends(get_email_service)):
email_service.send_email(recipient=recipient, subject=subject, body=body)
return {"message": "Xat yuborildi!"}
Tushuntirish:
- Biz
EmailServicebog'liqligining nusxalarini yaratadigan fabrika funksiyasini (create_email_service) belgilaymiz. get_email_servicebog'liqligi fabrika funksiyasini chaqirish vaEmailServicenusxasini taqdim etish uchunDependsva lambda'dan foydalanadi.send_emailendpoint funksiyasiEmailServicebog'liqligini kiritadi.
Ilg'or Mulohazalar
1. Skoplar va Hayot Davrlari
DI konteynerlari ko'pincha bog'liqliklarning hayot davrini boshqarish uchun xususiyatlarni taqdim etadi. Umumiy skoplar quyidagilarni o'z ichiga oladi:
- Singleton: Bog'liqlikning yagona nusxasi yaratiladi va ilovaning butun hayoti davomida qayta ishlatiladi. Bu holatsiz yoki global skopga ega bog'liqliklar uchun mos keladi.
- Vaqtinchalik (Transient): Har safar so'ralganda bog'liqlikning yangi nusxasi yaratiladi. Bu holatli yoki bir-biridan ajratilishi kerak bo'lgan bog'liqliklar uchun mos keladi.
- So'rov (Request): Har bir kiruvchi so'rov uchun bog'liqlikning yagona nusxasi yaratiladi. Bu bitta so'rov kontekstida holatni saqlashi kerak bo'lgan bog'liqliklar uchun mos keladi.
dependency_injector kutubxonasi skoplar uchun o'rnatilgan qo'llab-quvvatlashni ta'minlaydi. Maxsus konteynerlar uchun siz skopni boshqarish mantig'ini o'zingiz yozishingiz kerak bo'ladi.
2. Konfiguratsiya
Bog'liqliklar ko'pincha ma'lumotlar bazasi ulanish satrlari, API kalitlari va funksiyalarni yoqish/o'chirish bayroqlari kabi konfiguratsiya sozlamalarini talab qiladi. DI konteynerlari konfiguratsiya qiymatlariga kirish va ularni kiritishning markazlashtirilgan usulini taqdim etish orqali ushbu sozlamalarni boshqarishga yordam beradi.
dependency_injector misolida, config provayderi muhit o'zgaruvchilaridan konfiguratsiyani olish imkonini beradi. Maxsus konteynerlar uchun siz konfiguratsiyani fayllardan yoki muhit o'zgaruvchilaridan yuklab, ularni konteynerda saqlashingiz mumkin.
3. Testlash
DI'ning asosiy afzalliklaridan biri bu testlanuvchanlikning yaxshilanishidir. DI konteyneri yordamida siz testlash paytida haqiqiy bog'liqliklarni osongina soxta (mock) obyektlar yoki test dublyorlari bilan almashtirishingiz mumkin.
Misol (`dependency_injector` bilan testlash):
import pytest
from unittest.mock import MagicMock
from dependency_injector import containers, providers
from fastapi import FastAPI, Depends
from fastapi.testclient import TestClient
# Bog'liqliklarni aniqlash (avvalgidek)
class Database:
def __init__(self, connection_string: str):
self.connection_string = connection_string
def get_items(self):
return [{"id": 1, "name": "Item 1"}, {"id": 2, "name": "Item 2"}]
class UserRepository:
def __init__(self, database: Database):
self.database = database
def get_all_users(self):
return [{"id": "user1", "name": "Alice"},{"id": "user2", "name": "Bob"}]
class Settings:
def __init__(self, database_url):
self.database_url = database_url
# Konteynerni aniqlash (avvalgidek)
class Container(containers.DeclarativeContainer):
config = providers.Configuration()
settings = providers.Singleton(Settings, database_url = config.database_url)
database = providers.Singleton(Database, connection_string=config.database_url)
user_repository = providers.Factory(UserRepository, database=database)
# FastAPI ilovasini yaratish (avvalgidek)
app = FastAPI()
# Konteynerni sozlash (muhit o'zgaruvchisidan)
container = Container()
container.config.database_url.from_env("DATABASE_URL", default="sqlite:///:memory:")
container.wire([__name__]) # FastAPI endpoint'lariga bog'liqliklarni kiritishni yoqadi
# FastAPI uchun bog'liqlik
def get_user_repository(user_repository: UserRepository = Depends(container.user_repository.provided)) -> UserRepository:
return user_repository
# Kiritilgan bog'liqlikdan foydalanadigan endpoint (avvalgidek)
@app.get("/users/")
async def read_users(user_repository: UserRepository = Depends(get_user_repository)):
return user_repository.get_all_users()
@app.on_event("startup")
async def startup_event():
# Konteynerni initsializatsiya qilish
container.init_resources()
# Test
@pytest.fixture
def test_client():
# Ma'lumotlar bazasi bog'liqligini soxta (mock) bilan almashtirish
database_mock = MagicMock(spec=Database)
database_mock.get_items.return_value = [{"id": 3, "name": "Test Item"}]
user_repository_mock = MagicMock(spec = UserRepository)
user_repository_mock.get_all_users.return_value = [{"id": "test_user", "name": "Test User"}]
# Konteynerni soxta bog'liqliklar bilan almashtirish
container.user_repository.override(providers.Factory(lambda: user_repository_mock))
with TestClient(app) as client:
yield client
container.user_repository.reset()
def test_read_users(test_client: TestClient):
response = test_client.get("/users/")
assert response.status_code == 200
assert response.json() == [{"id": "test_user", "name": "Test User"}]
Tushuntirish:
- Biz
MagicMockyordamidaDatabasebog'liqligi uchun soxta obyekt yaratamiz. - Konteynerdagi
databaseprovayderinicontainer.database.override()yordamida soxta obyekt bilan almashtiramiz. test_read_itemstest funksiyasi endi soxta ma'lumotlar bazasi bog'liqligidan foydalanadi.- Test bajarilgandan so'ng, u konteynerning almashtirilgan bog'liqligini tiklaydi.
4. Asinxron Bog'liqliklar
FastAPI asinxron dasturlash (async/await) ustiga qurilgan. Asinxron bog'liqliklar (masalan, asinxron ma'lumotlar bazasi ulanishlari) bilan ishlaganda, sizning DI konteyneringiz va bog'liqlik provayderlaringiz asinxron operatsiyalarni qo'llab-quvvatlashiga ishonch hosil qiling.
Misol (`dependency_injector` bilan Asinxron Bog'liqlik):
import asyncio
from dependency_injector import containers, providers
from fastapi import FastAPI, Depends
# Asinxron bog'liqlikni aniqlash
class AsyncDatabase:
def __init__(self, connection_string: str):
self.connection_string = connection_string
async def connect(self):
print(f"Ma'lumotlar bazasiga ulanish: {self.connection_string}")
await asyncio.sleep(0.1) # Ulanish vaqtini simulyatsiya qilish
async def fetch_data(self):
await asyncio.sleep(0.1) # Ma'lumotlar bazasi so'rovini simulyatsiya qilish
return [{"id": 1, "name": "Async Item 1"}]
# Konteynerni aniqlash
class Container(containers.DeclarativeContainer):
config = providers.Configuration()
database = providers.Singleton(AsyncDatabase, connection_string=config.database_url)
# FastAPI ilovasini yaratish
app = FastAPI()
# Konteynerni sozlash
container = Container()
container.config.database_url.from_env("DATABASE_URL", default="sqlite:///:memory:")
container.wire([__name__])
# FastAPI uchun bog'liqlik
async def get_async_database(database: AsyncDatabase = Depends(container.database.provided)) -> AsyncDatabase:
await database.connect()
return database
# Kiritilgan bog'liqlikdan foydalanadigan endpoint
@app.get("/async-items/")
async def read_async_items(database: AsyncDatabase = Depends(get_async_database)):
data = await database.fetch_data()
return data
@app.on_event("startup")
async def startup_event():
# Konteynerni initsializatsiya qilish
container.init_resources()
Tushuntirish:
AsyncDatabasesinfiasyncvaawaityordamida asinxron metodlarni belgilaydi.get_async_databasebog'liqligi ham asinxron funksiya sifatida belgilangan.read_async_itemsendpoint funksiyasiasyncsifatida belgilangan vadatabase.fetch_data()natijasini kutadi.
To'g'ri Yondashuvni Tanlash
Ilg'or DI konteyner yaratish uchun eng yaxshi yondashuv ilovangizning murakkabligiga va sizning maxsus talablaringizga bog'liq:
- Kichik va o'rta hajmdagi loyihalar uchun: FastAPI'ning o'rnatilgan DI tizimi yoki
Dependsbilan fabrika funksiyasi yondashuvi yetarli bo'lishi mumkin. - Katta, murakkabroq loyihalar uchun:
dependency_injectorkabi maxsus DI kutubxonasi bog'liqliklarni boshqarish uchun keng qamrovli xususiyatlar to'plamini taqdim etadi. - DI jarayoni ustidan nozik nazorat talab qiladigan loyihalar uchun: Maxsus DI konteynerni yaratish eng yaxshi variant bo'lishi mumkin.
Xulosa
Bog'liqliklarni kiritish - bu o'lchamlanuvchi, qo'llab-quvvatlanadigan va testlanadigan ilovalar yaratish uchun kuchli usuldir. FastAPI'ning o'rnatilgan DI tizimi oddiy holatlar uchun a'lo darajada bo'lsa-da, ilg'or DI konteyner arxitekturasi murakkabroq loyihalar uchun sezilarli afzalliklarni taqdim etishi mumkin. To'g'ri yondashuvni tanlab va DI kutubxonalarining xususiyatlaridan foydalanib yoki maxsus konteyner yaratib, siz FastAPI ilovalaringizning umumiy sifati va qo'llab-quvvatlanuvchanligini yaxshilaydigan mustahkam va moslashuvchan bog'liqliklarni boshqarish tizimini yaratishingiz mumkin.
Global Mulohazalar
Global ilovalar uchun DI konteynerlarini loyihalashda quyidagilarni hisobga olish muhim:
- Mahalliylashtirish: Mahalliylashtirish bilan bog'liq bog'liqliklar (masalan, til sozlamalari, sana formatlari) turli mintaqalarda bir xillikni ta'minlash uchun DI konteyneri tomonidan boshqarilishi kerak.
- Vaqt Mintaqalari: Vaqt mintaqasi ma'lumotlarini qattiq kodlashdan saqlanish uchun vaqt mintaqasi konversiyalarini boshqaradigan bog'liqliklar kiritilishi kerak.
- Valyuta: Turli valyutalarni qo'llab-quvvatlash uchun valyuta konversiyasi va formatlash uchun bog'liqliklar konteyner tomonidan boshqarilishi kerak.
- Mintaqaviy Sozlamalar: Raqam formatlari va manzil formatlari kabi boshqa mintaqaviy sozlamalar ham DI konteyneri tomonidan boshqarilishi kerak.
- Ko'p ijarachilik (Multi-tenancy): Ko'p ijarachili ilovalar uchun DI konteyneri turli ijarachilar uchun turli bog'liqliklarni taqdim eta olishi kerak. Bunga skoplar yoki maxsus bog'liqliklarni hal qilish mantig'idan foydalanish orqali erishish mumkin.
- Muvofiqlik va Xavfsizlik: Sizning bog'liqliklarni boshqarish strategiyangiz turli mintaqalardagi tegishli ma'lumotlar maxfiyligi qoidalariga (masalan, GDPR, CCPA) va xavfsizlikning eng yaxshi amaliyotlariga mos kelishini ta'minlang. Maxfiy hisob ma'lumotlari va konfiguratsiyalarni konteyner ichida xavfsiz tarzda boshqaring.
Ushbu global omillarni hisobga olgan holda, siz global muhitda ishlaydigan ilovalarni yaratish uchun juda mos keladigan DI konteynerlarini yaratishingiz mumkin.